using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("CollectionManagerDisplay")]
	public class CollectionManagerDisplay : MonoBehaviour
	{
		public enum ViewMode
		{
			CARDS,
			HERO_SKINS,
			CARD_BACKS,
			DECK_TEMPLATE,
			COUNT
		}

		[Attribute38("CollectionManagerDisplay.ViewModeData")]
		public class ViewModeData : MonoClass
		{
			public string m_setPageByCard => method_4("m_setPageByCard");

			public TAG_PREMIUM m_setPageByPremium => method_2<TAG_PREMIUM>("m_setPageByPremium");

			public object m_pageTransitionCompleteData => method_3<object>("m_pageTransitionCompleteData");

			public ViewModeData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ViewModeData(IntPtr address)
				: this(address, "ViewModeData")
			{
			}
		}

		[Attribute38("CollectionManagerDisplay.CardSetIconMatOffset")]
		public class CardSetIconMatOffset : MonoClass
		{
			public TAG_CARD_SET m_cardSet => method_2<TAG_CARD_SET>("m_cardSet");

			public Vector2 m_offset => method_2<Vector2>("m_offset");

			public CardSetIconMatOffset(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardSetIconMatOffset(IntPtr address)
				: this(address, "CardSetIconMatOffset")
			{
			}
		}

		[Attribute38("CollectionManagerDisplay.TextureRequests")]
		public class TextureRequests : MonoClass
		{
			[Attribute38("CollectionManagerDisplay.TextureRequests.Request")]
			public class Request : MonoClass
			{
				public object m_callbackData => method_3<object>("m_callbackData");

				public Request(IntPtr address, string className)
					: base(address, className)
				{
				}

				public Request(IntPtr address)
					: this(address, "Request")
				{
				}
			}

			public List<Request> m_requests => method_3<Class271<Request>>("m_requests")?.method_25();

			public TextureRequests(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TextureRequests(IntPtr address)
				: this(address, "TextureRequests")
			{
			}
		}

		public CollectionCardVisual m_cardVisualPrefab => method_3<CollectionCardVisual>("m_cardVisualPrefab");

		public GameObject m_activeSearchBone => method_3<GameObject>("m_activeSearchBone");

		public GameObject m_activeSearchBone_Win8 => method_3<GameObject>("m_activeSearchBone_Win8");

		public GameObject m_craftingTrayHiddenBone => method_3<GameObject>("m_craftingTrayHiddenBone");

		public GameObject m_craftingTrayShownBone => method_3<GameObject>("m_craftingTrayShownBone");

		public Transform m_deckTemplateHiddenBone => method_3<Transform>("m_deckTemplateHiddenBone");

		public Transform m_deckTemplateShownBone => method_3<Transform>("m_deckTemplateShownBone");

		public Transform m_deckTemplateTutorialWelcomeBone => method_3<Transform>("m_deckTemplateTutorialWelcomeBone");

		public Transform m_deckTemplateTutorialReminderBone => method_3<Transform>("m_deckTemplateTutorialReminderBone");

		public Transform m_editDeckTutorialBone => method_3<Transform>("m_editDeckTutorialBone");

		public Transform m_convertDeckTutorialBone => method_3<Transform>("m_convertDeckTutorialBone");

		public Transform m_setFilterTutorialBone => method_3<Transform>("m_setFilterTutorialBone");

		public ManaFilterTabManager m_manaTabManager => method_3<ManaFilterTabManager>("m_manaTabManager");

		public CollectionPageManager m_pageManager => method_3<CollectionPageManager>("m_pageManager");

		public CollectionCoverDisplay m_cover => method_3<CollectionCoverDisplay>("m_cover");

		public CollectionSearch m_search => method_3<CollectionSearch>("m_search");

		public ActiveFilterButton m_filterButton => method_3<ActiveFilterButton>("m_filterButton");

		public CraftingModeButton m_craftingModeButton => method_3<CraftingModeButton>("m_craftingModeButton");

		public Notification m_deckTemplateCardReplacePopup => method_3<Notification>("m_deckTemplateCardReplacePopup");

		public PegUIElement m_inputBlocker => method_3<PegUIElement>("m_inputBlocker");

		public NestedPrefab m_setFilterTrayContainer => method_3<NestedPrefab>("m_setFilterTrayContainer");

		public Texture m_allSetsTexture => method_3<Texture>("m_allSetsTexture");

		public Vector2 m_allSetsIconOffset => method_2<Vector2>("m_allSetsIconOffset");

		public Texture m_wildSetsTexture => method_3<Texture>("m_wildSetsTexture");

		public Vector2 m_wildSetsIconOffset => method_2<Vector2>("m_wildSetsIconOffset");

		public CollectionPageLayoutSettings m_pageLayoutSettings => method_3<CollectionPageLayoutSettings>("m_pageLayoutSettings");

		public Material m_goldenCardNotOwnedMeshMaterial => method_3<Material>("m_goldenCardNotOwnedMeshMaterial");

		public Material m_cardNotOwnedMeshMaterial => method_3<Material>("m_cardNotOwnedMeshMaterial");

		public GameObject m_bookBack => method_3<GameObject>("m_bookBack");

		public string m_corkBackTexture => method_4("m_corkBackTexture");

		public Mesh m_tavernBrawlBookBackMesh => method_3<Mesh>("m_tavernBrawlBookBackMesh");

		public Material m_tavernBrawlElements => method_3<Material>("m_tavernBrawlElements");

		public List<GameObject> m_tavernBrawlObjectsToSwap => method_3<Class271<GameObject>>("m_tavernBrawlObjectsToSwap")?.method_25();

		public bool m_netCacheReady => method_2<bool>("m_netCacheReady");

		public bool m_isReady => method_2<bool>("m_isReady");

		public bool m_unloading => method_2<bool>("m_unloading");

		public List<CollectionCardActors> m_cardBackActors => method_3<Class271<CollectionCardActors>>("m_cardBackActors")?.method_25();

		public List<CollectionCardActors> m_previousCardBackActors => method_3<Class271<CollectionCardActors>>("m_previousCardBackActors")?.method_25();

		public List<CollectionCardActors> m_cardActors => method_3<Class271<CollectionCardActors>>("m_cardActors")?.method_25();

		public List<CollectionCardActors> m_previousCardActors => method_3<Class271<CollectionCardActors>>("m_previousCardActors")?.method_25();

		public int m_displayRequestID => method_2<int>("m_displayRequestID");

		public bool m_selectingNewDeckHero => method_2<bool>("m_selectingNewDeckHero");

		public long m_showDeckContentsRequest => method_2<long>("m_showDeckContentsRequest");

		public Notification m_deckHelpPopup => method_3<Notification>("m_deckHelpPopup");

		public Notification m_innkeeperLClickReminder => method_3<Notification>("m_innkeeperLClickReminder");

		public bool m_setFilterTrayInitialized => method_2<bool>("m_setFilterTrayInitialized");

		public bool m_isCoverLoading => method_2<bool>("m_isCoverLoading");

		public CraftingTray m_craftingTray => method_3<CraftingTray>("m_craftingTray");

		public SetFilterTray m_setFilterTray => method_3<SetFilterTray>("m_setFilterTray");

		public ViewMode m_currentViewMode => method_2<ViewMode>("m_currentViewMode");

		public DeckTemplatePicker m_deckTemplatePickerPhone => method_3<DeckTemplatePicker>("m_deckTemplatePickerPhone");

		public HeroPickerDisplay m_heroPickerDisplay => method_3<HeroPickerDisplay>("m_heroPickerDisplay");

		public int m_inputBlockers => method_2<int>("m_inputBlockers");

		public Notification m_createDeckNotification => method_3<Notification>("m_createDeckNotification");

		public Notification m_convertTutorialPopup => method_3<Notification>("m_convertTutorialPopup");

		public Notification m_setFilterTutorialPopup => method_3<Notification>("m_setFilterTutorialPopup");

		public bool m_showingDeckTemplateTips => method_2<bool>("m_showingDeckTemplateTips");

		public float m_deckTemplateTipWaitTime => method_2<float>("m_deckTemplateTipWaitTime");

		public bool m_searchTriggeredCraftingTray => method_2<bool>("m_searchTriggeredCraftingTray");

		public ShareableDeck m_cachedShareableDeck => method_3<ShareableDeck>("m_cachedShareableDeck");

		public static float CRAFTING_TRAY_SLIDE_IN_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "CollectionManagerDisplay", "CRAFTING_TRAY_SLIDE_IN_TIME");

		public CollectionManagerDisplay(IntPtr address, string className)
			: base(address, className)
		{
		}

		public CollectionManagerDisplay(IntPtr address)
			: this(address, "CollectionManagerDisplay")
		{
		}

		public static CollectionManagerDisplay Get()
		{
			return MonoClass.smethod_15<CollectionManagerDisplay>(TritonHs.MainAssemblyPath, "", "CollectionManagerDisplay", "Get", Array.Empty<object>());
		}

		public static string GetClassTextureAssetPath(TAG_CLASS classTag)
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "CollectionManagerDisplay", "GetClassTextureAssetPath", classTag);
		}

		public void Start()
		{
			method_8("Start");
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void OnApplicationFocus(bool hasFocus)
		{
			method_8("OnApplicationFocus", hasFocus);
		}

		public Material GetGoldenCardNotOwnedMeshMaterial()
		{
			return method_14<Material>("GetGoldenCardNotOwnedMeshMaterial", Array.Empty<object>());
		}

		public Material GetCardNotOwnedMeshMaterial()
		{
			return method_14<Material>("GetCardNotOwnedMeshMaterial", Array.Empty<object>());
		}

		public CollectionCardVisual GetCardVisualPrefab()
		{
			return method_14<CollectionCardVisual>("GetCardVisualPrefab", Array.Empty<object>());
		}

		public bool IsReady()
		{
			return method_11<bool>("IsReady", Array.Empty<object>());
		}

		public void Unload()
		{
			method_8("Unload");
		}

		public void Exit()
		{
			method_8("Exit");
		}

		public void RequestContentsToShowDeck(long deckID)
		{
			method_8("RequestContentsToShowDeck", deckID);
		}

		public CollectionPageLayoutSettings.Variables GetCurrentPageLayoutSettings()
		{
			return method_14<CollectionPageLayoutSettings.Variables>("GetCurrentPageLayoutSettings", Array.Empty<object>());
		}

		public CollectionPageLayoutSettings.Variables GetPageLayoutSettings(ViewMode viewMode)
		{
			return method_14<CollectionPageLayoutSettings.Variables>("GetPageLayoutSettings", new object[1] { viewMode });
		}

		public void ShowPhoneDeckTemplateTray()
		{
			method_8("ShowPhoneDeckTemplateTray");
		}

		public DeckTemplatePicker GetPhoneDeckTemplateTray()
		{
			return method_14<DeckTemplatePicker>("GetPhoneDeckTemplateTray", Array.Empty<object>());
		}

		public void SetViewMode(ViewMode mode, bool triggerResponse, ViewModeData userdata)
		{
			method_9("SetViewMode", new Class276.Enum20[3]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.Boolean,
				Class276.Enum20.Class
			}, mode, triggerResponse, userdata);
		}

		public void SetViewMode(ViewMode mode, ViewModeData userdata)
		{
			method_9("SetViewMode", new Class276.Enum20[2]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.Class
			}, mode, userdata);
		}

		public ViewMode GetViewMode()
		{
			return method_11<ViewMode>("GetViewMode", Array.Empty<object>());
		}

		public bool SetFilterTrayInitialized()
		{
			return method_11<bool>("SetFilterTrayInitialized", Array.Empty<object>());
		}

		public void OnDoneEditingDeck()
		{
			method_8("OnDoneEditingDeck");
		}

		public void FilterByManaCost(int cost)
		{
			method_8("FilterByManaCost", cost);
		}

		public void ShowOnlyCardsIOwn()
		{
			method_9("ShowOnlyCardsIOwn", new Class276.Enum20[0]);
		}

		public void ShowOnlyCardsIOwn(object obj)
		{
			method_9("ShowOnlyCardsIOwn", new Class276.Enum20[1] { Class276.Enum20.Class }, obj);
		}

		public void HideAllTips()
		{
			method_8("HideAllTips");
		}

		public void HideDeckHelpPopup()
		{
			method_8("HideDeckHelpPopup");
		}

		public void ShowInnkeeeprLClickHelp(bool isHero)
		{
			method_8("ShowInnkeeeprLClickHelp", isHero);
		}

		public void ShowPremiumCardsNotOwned(bool show)
		{
			method_8("ShowPremiumCardsNotOwned", show);
		}

		public void ShowPremiumCardsOnly()
		{
			method_8("ShowPremiumCardsOnly");
		}

		public void SetFilterCallback(object data, bool isWild)
		{
			method_8("SetFilterCallback", data, isWild);
		}

		public void ShowSet(object data)
		{
			method_8("ShowSet", data);
		}

		public void GoToPageWithCard(string cardID, TAG_PREMIUM premium)
		{
			method_8("GoToPageWithCard", cardID, premium);
		}

		public void UpdateCurrentPageCardLocks(bool playSound)
		{
			method_8("UpdateCurrentPageCardLocks", playSound);
		}

		public HeroPickerDisplay GetHeroPickerDisplay()
		{
			return method_14<HeroPickerDisplay>("GetHeroPickerDisplay", Array.Empty<object>());
		}

		public void EnterSelectNewDeckHeroMode()
		{
			method_8("EnterSelectNewDeckHeroMode");
		}

		public void ExitSelectNewDeckHeroMode()
		{
			method_8("ExitSelectNewDeckHeroMode");
		}

		public void CancelSelectNewDeckHeroMode()
		{
			method_8("CancelSelectNewDeckHeroMode");
		}

		public bool ShouldShowNewCardGlow(string cardID, TAG_PREMIUM premium)
		{
			return method_11<bool>("ShouldShowNewCardGlow", new object[2] { cardID, premium });
		}

		public bool CanViewHeroSkins()
		{
			return method_11<bool>("CanViewHeroSkins", Array.Empty<object>());
		}

		public bool CanViewCardBacks()
		{
			return method_11<bool>("CanViewCardBacks", Array.Empty<object>());
		}

		public void ResetFilters(bool updateVisuals)
		{
			method_8("ResetFilters", updateVisuals);
		}

		public void ShowAppropriateSetFilters()
		{
			method_8("ShowAppropriateSetFilters");
		}

		public void UpdateSetFilters(bool showWild, bool editingDeck, bool showUnownedSets)
		{
			method_8("UpdateSetFilters", showWild, editingDeck, showUnownedSets);
		}

		public bool SetFilterIsDefaultSelection()
		{
			return method_11<bool>("SetFilterIsDefaultSelection", Array.Empty<object>());
		}

		public bool IsShowingSetFilterTray()
		{
			return method_11<bool>("IsShowingSetFilterTray", Array.Empty<object>());
		}

		public bool IsSelectingNewDeckHero()
		{
			return method_11<bool>("IsSelectingNewDeckHero", Array.Empty<object>());
		}

		public void OnCollectionLoaded()
		{
			method_8("OnCollectionLoaded");
		}

		public void OnDeckContents(long deckID)
		{
			method_8("OnDeckContents", deckID);
		}

		public void OnDeckCreatedByPlayer(long deckID)
		{
			method_8("OnDeckCreatedByPlayer", deckID);
		}

		public void OnNewCardSeen(string cardID, TAG_PREMIUM premium)
		{
			method_8("OnNewCardSeen", cardID, premium);
		}

		public void OnCardRewardInserted(string cardID, TAG_PREMIUM premium)
		{
			method_8("OnCardRewardInserted", cardID, premium);
		}

		public void OnCollectionChanged()
		{
			method_8("OnCollectionChanged");
		}

		public void OnNetCacheReady()
		{
			method_8("OnNetCacheReady");
		}

		public void OnShowAdvancedCMChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnShowAdvancedCMChanged", option, prevValue, existed, userData);
		}

		public void OnCardTileRightClicked(DeckTrayDeckTileVisual cardTile)
		{
			method_8("OnCardTileRightClicked", cardTile);
		}

		public void LoadAllClassTextures()
		{
			method_8("LoadAllClassTextures");
		}

		public void UnloadAllClassTextures()
		{
			method_8("UnloadAllClassTextures");
		}

		public void SetTavernBrawlTexturesIfNecessary()
		{
			method_8("SetTavernBrawlTexturesIfNecessary");
		}

		public void OnClassTextureLoaded(AssetReference assetRef, object asset, object callbackData)
		{
			method_8("OnClassTextureLoaded", assetRef, asset, callbackData);
		}

		public void EnableInput(bool enable)
		{
			method_8("EnableInput", enable);
		}

		public TAG_CLASS GetDeckHeroClass(long deckID)
		{
			return method_11<TAG_CLASS>("GetDeckHeroClass", new object[1] { deckID });
		}

		public void DoBookClosingAnimations()
		{
			method_8("DoBookClosingAnimations");
		}

		public void ShowAdvancedCollectionManager(bool show)
		{
			method_8("ShowAdvancedCollectionManager", show);
		}

		public void AddSetFilters(bool isWild)
		{
			method_8("AddSetFilters", isWild);
		}

		public void AddSetFilter(TAG_CARD_SET cardSet)
		{
			method_8("AddSetFilter", cardSet);
		}

		public void OnCoverLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnCoverLoaded", assetRef, go, callbackData);
		}

		public void OnInputBlockerRelease(UIEvent e)
		{
			method_8("OnInputBlockerRelease", e);
		}

		public void OnSearchActivated()
		{
			method_8("OnSearchActivated");
		}

		public void OnSearchDeactivated(string oldSearchText, string newSearchText)
		{
			method_8("OnSearchDeactivated", oldSearchText, newSearchText);
		}

		public void OnSearchCleared(bool updateVisuals)
		{
			method_8("OnSearchCleared", updateVisuals);
		}

		public void ShowTavernBrawlDeck(long deckID)
		{
			method_8("ShowTavernBrawlDeck", deckID);
		}

		public void DoEnterCollectionManagerEvents()
		{
			method_8("DoEnterCollectionManagerEvents");
		}

		public void OpenBookImmediately()
		{
			method_8("OpenBookImmediately");
		}

		public void ShowCraftingTipIfNeeded()
		{
			method_8("ShowCraftingTipIfNeeded");
		}

		public Vector3 GetNewDeckPosition()
		{
			return method_11<Vector3>("GetNewDeckPosition", Array.Empty<object>());
		}

		public Vector3 GetLastDeckPosition()
		{
			return method_11<Vector3>("GetLastDeckPosition", Array.Empty<object>());
		}

		public Vector3 GetMiddleDeckPosition()
		{
			return method_11<Vector3>("GetMiddleDeckPosition", Array.Empty<object>());
		}

		public void ShowSetRotationNewDeckIndicator(float f)
		{
			method_8("ShowSetRotationNewDeckIndicator", f);
		}

		public void ShowDeckTemplateTipsIfNeeded()
		{
			method_8("ShowDeckTemplateTipsIfNeeded");
		}

		public void OnCoverOpened()
		{
			method_8("OnCoverOpened");
		}

		public void OnSwitchViewModeResponse(bool triggerResponse, ViewMode prevMode, ViewMode newMode, ViewModeData userdata)
		{
			method_8("OnSwitchViewModeResponse", triggerResponse, prevMode, newMode, userdata);
		}

		public void EnableSearchUI(ViewMode viewMode)
		{
			method_8("EnableSearchUI", viewMode);
		}

		public void OnCraftingTrayLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnCraftingTrayLoaded", assetRef, go, callbackData);
		}

		public void OnCraftingModeButtonReleased(UIEvent e)
		{
			method_8("OnCraftingModeButtonReleased", e);
		}

		public void HideCraftingTray()
		{
			method_8("HideCraftingTray");
		}

		public void ShowConvertTutorial(UserAttentionBlocker blocker)
		{
			method_8("ShowConvertTutorial", blocker);
		}

		public void HideConvertTutorial()
		{
			method_8("HideConvertTutorial");
		}

		public void ShowSetFilterTutorial(UserAttentionBlocker blocker)
		{
			method_8("ShowSetFilterTutorial", blocker);
		}

		public void HideSetFilterTutorial()
		{
			method_8("HideSetFilterTutorial");
		}

		public void ShowStandardInfoTutorial(UserAttentionBlocker blocker)
		{
			method_8("ShowStandardInfoTutorial", blocker);
		}

		public void CheckClipboardAndPromptPlayerToPaste()
		{
			method_8("CheckClipboardAndPromptPlayerToPaste");
		}

		public void PasteFromClipboardIfValidOrShowStatusMessage()
		{
			method_8("PasteFromClipboardIfValidOrShowStatusMessage");
		}

		public bool CanPasteShareableDeck(ShareableDeck shareableDeck)
		{
			return method_10<bool>("CanPasteShareableDeck", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { shareableDeck });
		}

		public void CreateDeckFromClipboard(ShareableDeck shareableDeck)
		{
			method_8("CreateDeckFromClipboard", shareableDeck);
		}

		public void OnDeckCreatedFromClipboard(long deckId)
		{
			method_8("OnDeckCreatedFromClipboard", deckId);
		}

		public void OnCollectionDeckTrayModeSwitched()
		{
			method_8("OnCollectionDeckTrayModeSwitched");
		}

		public void RejectDeckFromClipboard()
		{
			method_8("RejectDeckFromClipboard");
		}
	}
}
